x += dx;
w -= dx;
break;
+ default:
+ break;
}
x = MAX (x, 0);
if (event->button.button == mv_resize->moveresize_button)
finish_drag (mv_resize);
break;
+ default:
+ break;
}
return TRUE;
}
mv_resize->moveresize_orig_x = rect.x + rect.width - width;
mv_resize->moveresize_orig_y = rect.y + rect.height - height;
break;
+ case GDK_GRAVITY_STATIC:
default:
mv_resize->moveresize_orig_x = rect.x;
mv_resize->moveresize_orig_y = rect.y;
info = &g_array_index (device->axes, GdkAxisInfo, index_);
info->use = use;
- switch (use)
+ switch ((guint) use)
{
case GDK_AXIS_X:
case GDK_AXIS_Y:
axis_info.max_value = max_value;
axis_info.resolution = resolution;
- switch (use)
+ switch ((guint) use)
{
case GDK_AXIS_X:
case GDK_AXIS_Y:
GdkDragContext *context = NULL;
GList *l;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_DRAG_MOTION:
case GDK_DROP_START:
* since I trust bytewise 0 == 0. less than for integers
* or pointers.
*/
- switch (type)
+ switch ((guint) type)
{
case GDK_MOTION_NOTIFY:
new_event->motion.x = 0.;
g_set_object (&new_private->user_data, private->user_data);
}
- switch (event->any.type)
+ switch ((guint) event->any.type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
g_clear_object (&private->user_data);
}
- switch (event->any.type)
+ switch ((guint) event->any.type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
case GDK_OWNER_CHANGE:
case GDK_GRAB_BROKEN:
case GDK_EVENT_LAST:
+ default:
/* return current time */
break;
}
case GDK_PAD_STRIP:
case GDK_PAD_GROUP_MODE:
case GDK_EVENT_LAST:
+ default:
/* no state field */
break;
}
g_return_val_if_fail (event != NULL, FALSE);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_CONFIGURE:
x = event->configure.x;
g_return_val_if_fail (event != NULL, FALSE);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_MOTION_NOTIFY:
x = event->motion.x_root;
{
g_return_if_fail (event != NULL);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_CONFIGURE:
event->configure.x = x;
g_return_val_if_fail (event != NULL, FALSE);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
g_return_val_if_fail (event != NULL, FALSE);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
gboolean fetched = TRUE;
guint number = 0;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
gboolean fetched = TRUE;
guint16 number = 0;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
{
gboolean fetched = TRUE;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
{
gboolean fetched = TRUE;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
{
gboolean fetched = TRUE;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
gboolean fetched = TRUE;
GdkScrollDirection dir = 0;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_SCROLL:
if (event->scroll.direction == GDK_SCROLL_SMOOTH)
gdouble dx = 0.0;
gdouble dy = 0.0;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_SCROLL:
if (event->scroll.direction == GDK_SCROLL_SMOOTH)
{
gdouble x, y;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_MOTION_NOTIFY:
x = event->motion.x;
g_set_object (&private->device, device);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_MOTION_NOTIFY:
event->motion.device = device;
return private->device;
}
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_MOTION_NOTIFY:
return event->motion.device;
case GDK_PROXIMITY_IN:
case GDK_PROXIMITY_OUT:
return event->proximity.device;
- default:
- break;
- }
-
- /* Fallback if event has no device set */
- switch (event->type)
- {
- case GDK_MOTION_NOTIFY:
- case GDK_BUTTON_PRESS:
- case GDK_BUTTON_RELEASE:
- case GDK_TOUCH_BEGIN:
- case GDK_TOUCH_UPDATE:
- case GDK_TOUCH_END:
- case GDK_TOUCH_CANCEL:
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
case GDK_FOCUS_CHANGE:
- case GDK_PROXIMITY_IN:
- case GDK_PROXIMITY_OUT:
case GDK_DRAG_ENTER:
case GDK_DRAG_LEAVE:
case GDK_DRAG_MOTION:
case GDK_DRAG_STATUS:
case GDK_DROP_START:
case GDK_DROP_FINISHED:
- case GDK_SCROLL:
case GDK_GRAB_BROKEN:
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
case GDK_WINDOW_FOREIGN:
case GDK_WINDOW_ROOT:
case GDK_WINDOW_CHILD:
+ default:
break;
}
}
}
/* fallthrough */
case GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS:
+ default:
;
}
}
return "geometry";
case GL_FRAGMENT_SHADER:
return "fragment";
+ default:
+ return "unknown";
}
- return "unknown";
}
static guint
symbol != GDK_KEY_Greek_finalsmallsigma)
xupper -= (GDK_KEY_Greek_alpha - GDK_KEY_Greek_ALPHA);
break;
+
+ default:
+ break;
}
if (lower)
priv = gdk_seat_default_get_instance_private (GDK_SEAT_DEFAULT (seat));
/* There must be only one flag set */
- switch (capability)
+ switch ((guint) capability)
{
case GDK_SEAT_CAPABILITY_POINTER:
case GDK_SEAT_CAPABILITY_TOUCH:
return GDK_SEAT_CAPABILITY_TOUCH;
case GDK_SOURCE_MOUSE:
case GDK_SOURCE_TOUCHPAD:
+ case GDK_SOURCE_PEN:
+ case GDK_SOURCE_ERASER:
+ case GDK_SOURCE_CURSOR:
+ case GDK_SOURCE_TRACKPOINT:
+ case GDK_SOURCE_TABLET_PAD:
default:
return GDK_SEAT_CAPABILITY_POINTER;
}
return "A surface has changed in such a way that it is no longer compatible with the swapchain.";
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
return "The display used by a swapchain does not use the same presentable image layout, or is incompatible in a way that prevents sharing an image.";
+ case VK_ERROR_VALIDATION_FAILED_EXT:
+ return "The application caused the validation layer to fail.";
+ case VK_ERROR_INVALID_SHADER_NV:
+ return "One or more shaders failed to compile or link.";
+ case VK_RESULT_RANGE_SIZE:
+ case VK_RESULT_MAX_ENUM:
default:
return "Unknown Vulkan error.";
}
switch (window->window_type)
{
+ default:
+ g_assert_not_reached ();
+ break;
+
case GDK_WINDOW_ROOT:
if (!screen->closed)
{
if (event_in_queue && event_in_queue->any.send_event)
event->any.send_event = TRUE;
- switch (type)
+ switch ((guint) type)
{
case GDK_MOTION_NOTIFY:
event->motion.time = the_time;
return "finger";
case WL_POINTER_AXIS_SOURCE_CONTINUOUS:
return "continuous";
+ case WL_POINTER_AXIS_SOURCE_WHEEL_TILT:
+ return "wheel-tilt";
default:
return "unknown";
}
}
return seat->continuous_scrolling;
+ case WL_POINTER_AXIS_SOURCE_WHEEL_TILT:
default:
return seat->pointer;
}
case ZWP_TABLET_TOOL_V2_CAPABILITY_SLIDER:
tool->axes |= GDK_AXIS_FLAG_SLIDER;
break;
+ default:
+ break;
}
}
if (!event)
return;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_MOTION_NOTIFY:
event->motion.time = time;
GdkWindow *window;
GdkEvent *event;
- switch (type)
+ switch ((guint) type)
{
case GDK_DRAG_ENTER:
case GDK_DRAG_LEAVE:
case PANGO_DIRECTION_LTR:
rtl[layout]--;
break;
+ case PANGO_DIRECTION_TTB_LTR:
+ case PANGO_DIRECTION_TTB_RTL:
+ case PANGO_DIRECTION_WEAK_LTR:
+ case PANGO_DIRECTION_WEAK_RTL:
+ case PANGO_DIRECTION_NEUTRAL:
default:
break;
}
order = GSD_FONT_RGBA_ORDER_RGB;
}
- xft_settings.antialias = (antialiasing != GSD_FONT_ANTIALIASING_MODE_NONE);
xft_settings.hinting = (hinting != GSD_FONT_HINTING_NONE);
xft_settings.dpi = get_dpi_from_gsettings (screen_wayland) * 1024; /* Xft wants 1/1024ths of an inch */
- xft_settings.rgba = "rgb";
- xft_settings.hintstyle = "hintfull";
switch (hinting)
{
xft_settings.hintstyle = "hintmedium";
break;
case GSD_FONT_HINTING_FULL:
+ default:
xft_settings.hintstyle = "hintfull";
break;
}
case GSD_FONT_RGBA_ORDER_RGBA:
xft_settings.rgba = "rgba";
break;
+ default:
case GSD_FONT_RGBA_ORDER_RGB:
xft_settings.rgba = "rgb";
break;
switch (antialiasing)
{
+ default:
case GSD_FONT_ANTIALIASING_MODE_NONE:
xft_settings.antialias = FALSE;
break;
switch (rect_anchor)
{
+ default:
case GDK_GRAVITY_STATIC:
case GDK_GRAVITY_NORTH_WEST:
x = anchor_rect.x;
switch (window_anchor)
{
+ default:
case GDK_GRAVITY_STATIC:
case GDK_GRAVITY_NORTH_WEST:
break;
{
switch (anchor)
{
+ default:
case GDK_GRAVITY_STATIC:
case GDK_GRAVITY_NORTH_WEST:
return GDK_GRAVITY_NORTH_EAST;
{
switch (anchor)
{
+ default:
case GDK_GRAVITY_STATIC:
case GDK_GRAVITY_NORTH_WEST:
return GDK_GRAVITY_SOUTH_WEST;
}
/* Yet we need to keep the window type hint tests for compatibility */
- switch (impl->hint)
+ switch ((guint) impl->hint)
{
case GDK_WINDOW_TYPE_HINT_POPUP_MENU:
case GDK_WINDOW_TYPE_HINT_DROPDOWN_MENU:
double x, y;
uint32_t serial;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
handle_get_geometry_reply (dpy, state, repl);
}
break;
+ default:
+ break;
}
}
value = ((XIValuatorClassInfo *) class_info)->value;
use = gdk_device_get_axis_use (device, j);
- switch (use)
+ switch ((guint) use)
{
case GDK_AXIS_X:
case GDK_AXIS_Y:
use = gdk_device_get_axis_use (device, i);
val = *vals++;
- switch (use)
+ switch ((guint) use)
{
case GDK_AXIS_X:
case GDK_AXIS_Y:
g_message ("visibility notify:\twindow: %ld full",
xevent->xvisibility.window);
break;
+ default:
+ break;
}
#endif /* G_ENABLE_DEBUG */
event->visibility.state = GDK_VISIBILITY_PARTIAL;
break;
+ default:
case VisibilityUnobscured:
event->visibility.state = GDK_VISIBILITY_UNOBSCURED;
break;
case XkbStateNotify:
_gdk_x11_keymap_state_changed (display, xevent);
break;
+ default:
+ break;
}
}
else
case '\\':
g_string_append_c (message, '\\');
break;
+ default:
+ break;
}
g_string_append_c (message, *p);
xdnd_send_leave (context_x11);
break;
case GDK_DRAG_PROTO_ROOTWIN:
+ case GDK_DRAG_PROTO_MOTIF:
+ case GDK_DRAG_PROTO_WIN32_DROPFILES:
+ case GDK_DRAG_PROTO_OLE2:
+ case GDK_DRAG_PROTO_LOCAL:
+ case GDK_DRAG_PROTO_WAYLAND:
case GDK_DRAG_PROTO_NONE:
default:
break;
break;
case GDK_DRAG_PROTO_ROOTWIN:
+ case GDK_DRAG_PROTO_MOTIF:
+ case GDK_DRAG_PROTO_WIN32_DROPFILES:
+ case GDK_DRAG_PROTO_OLE2:
+ case GDK_DRAG_PROTO_LOCAL:
+ case GDK_DRAG_PROTO_WAYLAND:
case GDK_DRAG_PROTO_NONE:
default:
break;
gdk_event_free (temp_event);
}
break;
+ case GDK_DRAG_PROTO_MOTIF:
+ case GDK_DRAG_PROTO_WIN32_DROPFILES:
+ case GDK_DRAG_PROTO_OLE2:
+ case GDK_DRAG_PROTO_LOCAL:
+ case GDK_DRAG_PROTO_WAYLAND:
case GDK_DRAG_PROTO_NONE:
- g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_motion()");
+ g_warning ("Invalid drag protocol %u in gdk_drag_motion()", context->protocol);
break;
default:
break;
case GDK_DRAG_PROTO_NONE:
g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_drop()");
break;
+ case GDK_DRAG_PROTO_MOTIF:
+ case GDK_DRAG_PROTO_WIN32_DROPFILES:
+ case GDK_DRAG_PROTO_OLE2:
+ case GDK_DRAG_PROTO_LOCAL:
+ case GDK_DRAG_PROTO_WAYLAND:
default:
+ g_warning ("Drag protocol %u is not valid in gdk_drag_drop()", context->protocol);
break;
}
}
case GDK_KEY_KP_Right:
dx = (state & GDK_MOD1_MASK) ? BIG_STEP : SMALL_STEP;
break;
+
+ default:
+ break;
}
}
if (!x11_context->grab_seat && event->type != GDK_DROP_FINISHED)
return FALSE;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_MOTION_NOTIFY:
return gdk_dnd_handle_motion_event (context, &event->motion);
case PANGO_DIRECTION_LTR:
rtl_minus_ltr--;
break;
+ case PANGO_DIRECTION_TTB_LTR:
+ case PANGO_DIRECTION_TTB_RTL:
+ case PANGO_DIRECTION_WEAK_LTR:
+ case PANGO_DIRECTION_WEAK_RTL:
+ case PANGO_DIRECTION_NEUTRAL:
default:
break;
}
{
GdkX11Keymap *keymap_x11 = GDK_X11_KEYMAP (keymap);
- switch (intent)
- {
- case GDK_MODIFIER_INTENT_SHIFT_GROUP:
- return keymap_x11->group_switch_mask;
+ if (intent == GDK_MODIFIER_INTENT_SHIFT_GROUP)
+ return keymap_x11->group_switch_mask;
- default:
- return GDK_KEYMAP_CLASS (gdk_x11_keymap_parent_class)->get_modifier_mask (keymap,
- intent);
- }
+ return GDK_KEYMAP_CLASS (gdk_x11_keymap_parent_class)->get_modifier_mask (keymap,
+ intent);
}
static void
return GDK_GRAB_NOT_VIEWABLE;
case GrabFrozen:
return GDK_GRAB_FROZEN;
+ default:
+ g_assert_not_reached();
+ return 0;
}
-
- g_assert_not_reached();
-
- return 0;
}
/*
case DirectColor:
visuals[nvisuals]->type = GDK_VISUAL_DIRECT_COLOR;
break;
+ default:
+ g_warn_if_reached ();
+ break;
}
visuals[nvisuals]->depth = visual_list[i].depth;
break;
case GDK_WINDOW_CHILD:
+ default:
g_assert_not_reached ();
break;
}
case GDK_WINDOW_FOREIGN:
case GDK_WINDOW_ROOT:
case GDK_WINDOW_CHILD:
+ default:
break;
}
x += dx;
w -= dx;
break;
+ default:
+ break;
}
x = MAX (x, 0);
finish_drag (mv_resize);
}
break;
+ default:
+ break;
}
}
break;
#endif
+ default:
+ break;
+
}
return TRUE;
}
mv_resize->moveresize_orig_x = rect.x + rect.width - width;
mv_resize->moveresize_orig_y = rect.y + rect.height - height;
break;
+ case GDK_GRAVITY_STATIC:
default:
mv_resize->moveresize_orig_x = rect.x;
mv_resize->moveresize_orig_y = rect.y;
double x_root, y_root;
XClientMessageEvent xclient = { 0 };
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
case GSK_SCALING_FILTER_TRILINEAR:
*min_filter_r = GL_LINEAR_MIPMAP_LINEAR;
break;
+
+ default:
+ break;
}
switch (node->mag_filter)
*/
case GSK_SCALING_FILTER_LINEAR:
case GSK_SCALING_FILTER_TRILINEAR:
+ default:
*mag_filter_r = GL_LINEAR;
break;
}
g_assert_not_reached ();
return;
+ case GSK_LINEAR_GRADIENT_NODE:
+ case GSK_REPEATING_LINEAR_GRADIENT_NODE:
+ case GSK_BORDER_NODE:
+ case GSK_INSET_SHADOW_NODE:
+ case GSK_OUTSET_SHADOW_NODE:
+ case GSK_OPACITY_NODE:
+ case GSK_CLIP_NODE:
+ case GSK_ROUNDED_CLIP_NODE:
+ case GSK_TEXT_NODE:
+ case GSK_BLUR_NODE:
default:
{
cairo_surface_t *surface;
/* Construct-only */
priv->display = g_value_dup_object (value);
break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
}
}
case PROP_DISPLAY:
g_value_set_object (value, priv->display);
break;
+
+ default:
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
+ break;
}
}
*/
return FALSE;
}
+
+ default:
+ g_assert_not_reached ();
+ return FALSE;
}
return TRUE;
case GSK_VULKAN_CLIP_ROUNDED:
/* XXX: improve */
return FALSE;
+
+ default:
+ g_assert_not_reached ();
+ return FALSE;
}
return TRUE;
cairo_surface_t *surface;
cairo_t *cr;
- switch (gsk_render_node_get_node_type (node))
+ switch ((guint) gsk_render_node_get_node_type (node))
{
case GSK_TEXTURE_NODE:
if (graphene_rect_equal (bounds, &node->bounds))
}
break;
- default: ;
+ default:
{
VkSemaphore semaphore;
graphene_rect_t view;
*width = gdk_pixbuf_animation_get_width (animation);
break;
}
+ case GTK_IMAGE_EMPTY:
+ case GTK_IMAGE_SURFACE:
default:
{
*height = -1;
switch (gtk_box_get_baseline_position (GTK_BOX (widget)))
{
+ default:
case GTK_BASELINE_POSITION_TOP:
break;
case GTK_BASELINE_POSITION_CENTER:
switch (gtk_box_get_baseline_position (GTK_BOX (widget)))
{
case GTK_BASELINE_POSITION_TOP:
+ default:
/* keep baseline as is */
break;
case GTK_BASELINE_POSITION_CENTER:
break;
+ case GTK_BUTTONBOX_EXPAND:
default:
g_assert_not_reached ();
break;
{
guint expected_token;
- switch (scanner->next_token)
+ if (scanner->next_token == G_TOKEN_STRING)
{
- case G_TOKEN_STRING:
expected_token = gtk_binding_parse_signal (scanner,
binding_set,
keyval,
modifiers);
if (expected_token != G_TOKEN_NONE)
return expected_token;
- break;
- default:
+ }
+ else
+ {
g_scanner_get_next_token (scanner);
return '}';
}
gdk_threads_leave ();
break;
+ case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
+ case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
+ case G_FILE_MONITOR_EVENT_UNMOUNTED:
+ case G_FILE_MONITOR_EVENT_MOVED:
+ case G_FILE_MONITOR_EVENT_RENAMED:
+ case G_FILE_MONITOR_EVENT_MOVED_IN:
+ case G_FILE_MONITOR_EVENT_MOVED_OUT:
default:
/* ignore at the moment */
break;
case GTK_BASELINE_POSITION_BOTTOM:
baseline = height - minimum_below;
break;
+ default:
+ break;
}
}
min_baseline = minimum - minimum_below;
nat_baseline = natural - natural_below;
break;
+ default:
+ break;
}
}
computed_minimum_baseline = computed_minimum - computed_minimum_below;
computed_natural_baseline = computed_natural - computed_natural_below;
break;
+ default:
+ break;
}
}
calendar_select_and_focus_day (calendar, day);
}
+ default:
+ break;
}
return return_val;
return PANGO_FONT_MASK_STRETCH;
case PROP_SIZE_SET:
return PANGO_FONT_MASK_SIZE;
+ default:
+ return 0;
}
-
- return 0;
}
static void
g_value_get_double (value) * PANGO_SCALE);
g_object_notify_by_pspec (object, pspec);
break;
+ default:
+ break;
}
if (priv->fixed_height_rows != -1)
uline = PANGO_UNDERLINE_DOUBLE;
break;
+ case PANGO_UNDERLINE_DOUBLE:
+ case PANGO_UNDERLINE_LOW:
+ case PANGO_UNDERLINE_ERROR:
default:
break;
}
min_baseline = total_min - below_min;
nat_baseline = total_nat - below_nat;
break;
+ default:
+ break;
}
if (minimum_baseline)
*/
switch (self->baseline_pos)
{
+ default:
case GTK_BASELINE_POSITION_TOP:
baseline = min_above;
break;
found = tree_first (combo_box, priv->model, &new_iter);
break;
+ case GTK_SCROLL_NONE:
+ case GTK_SCROLL_JUMP:
default:
return;
}
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
return gtk_container_focus_sort_left_right (container, visible_children, direction, old_focus);
+ default:
+ g_assert_not_reached ();
+ return NULL;
}
-
- g_assert_not_reached ();
-
- return NULL;
}
static gboolean
case COLOR_TYPE_WIN32:
gtk_win32_theme_unref (color->sym_col.win32.theme);
break;
+ case COLOR_TYPE_LITERAL:
+ case COLOR_TYPE_CURRENT_COLOR:
default:
break;
}
case COLOR_MIX:
value = _gtk_css_color_value_new_mix (child1, child2, d);
break;
+ case COLOR_RGB:
+ case COLOR_RGBA:
+ case COLOR_WIN32:
default:
g_assert_not_reached ();
value = NULL;
size = MIN (width, height);
cairo_translate (cr, width / 2.0, height / 2.0);
- switch (image_type)
+ switch ((guint) image_type)
{
case GTK_CSS_IMAGE_BUILTIN_ARROW_UP:
break;
case GTK_CSS_FONT_KERNING_NONE:
append_separated (s, "kern 0");
break;
- default: ;
+ case GTK_CSS_FONT_KERNING_AUTO:
+ default:
+ break;
}
value = gtk_css_style_get_value (style, GTK_CSS_PROPERTY_FONT_VARIANT_LIGATURES);
case GTK_CSS_FONT_VARIANT_POSITION_SUPER:
append_separated (s, "sups 1");
break;
- default: ;
+ case GTK_CSS_FONT_VARIANT_POSITION_NORMAL:
+ default:
+ break;
}
value = gtk_css_style_get_value (style, GTK_CSS_PROPERTY_FONT_VARIANT_CAPS);
break;
case GTK_CSS_FONT_VARIANT_CAPS_TITLING_CAPS:
append_separated (s, "titl 1");
- break;
- default: ;
+ break;
+ case GTK_CSS_FONT_VARIANT_CAPS_NORMAL:
+ default:
+ break;
}
value = gtk_css_style_get_value (style, GTK_CSS_PROPERTY_FONT_VARIANT_NUMERIC);
case GTK_CSS_FONT_VARIANT_ALTERNATE_HISTORICAL_FORMS:
append_separated (s, "hist 1");
break;
- default: ;
+ case GTK_CSS_FONT_VARIANT_ALTERNATE_NORMAL:
+ default:
+ break;
}
value = gtk_css_style_get_value (style, GTK_CSS_PROPERTY_FONT_VARIANT_EAST_ASIAN);
break;
case CAIRO_PATTERN_TYPE_LINEAR:
case CAIRO_PATTERN_TYPE_RADIAL:
+ case CAIRO_PATTERN_TYPE_MESH:
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
g_string_append (string, "none /* FIXME: add support for printing gradients */");
break;
case CAIRO_PATTERN_TYPE_SOLID:
return CAIRO_OPERATOR_EXCLUSION;
case GSK_BLEND_MODE_HARD_LIGHT:
return CAIRO_OPERATOR_HARD_LIGHT;
+ case GSK_BLEND_MODE_SOFT_LIGHT:
+ return CAIRO_OPERATOR_SOFT_LIGHT;
case GSK_BLEND_MODE_HUE:
return CAIRO_OPERATOR_HSL_HUE;
case GSK_BLEND_MODE_LIGHTEN:
return value1->val.part.part == value2->val.part.part
&& value1->val.part.state == value2->val.part.state;
+ case GTK_WIN32_PART_BORDER_TOP:
+ case GTK_WIN32_PART_BORDER_RIGHT:
+ case GTK_WIN32_PART_BORDER_BOTTOM:
+ case GTK_WIN32_PART_BORDER_LEFT:
default:
g_assert_not_reached ();
return FALSE;
info = gtk_drag_get_dest_info (context, TRUE);
/* Find the widget for the event */
- switch (event_type)
+ switch ((guint) event_type)
{
case GDK_DRAG_ENTER:
break;
if (!info)
return;
- switch (gdk_event_get_event_type (event))
+ switch ((guint) gdk_event_get_event_type (event))
{
case GDK_DRAG_STATUS:
{
gtk_drag_cancel_internal (info, GTK_DRAG_RESULT_NO_TARGET, time);
}
break;
+
+ default:
+ break;
}
}
sequence = gdk_event_get_event_sequence (event);
device = gdk_event_get_device (event);
- switch (gdk_event_get_event_type (event))
+ switch ((guint) gdk_event_get_event_type (event))
{
case GDK_TOUCH_BEGIN:
if (icon_info->current_sequence)
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PAGES:
case GTK_MOVEMENT_HORIZONTAL_PAGES:
+ default:
break;
}
}
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PAGES:
case GTK_MOVEMENT_HORIZONTAL_PAGES:
+ default:
break;
}
}
case GTK_DELETE_WHITESPACE:
gtk_entry_delete_whitespace (entry);
break;
+
+ default:
+ break;
}
if (gtk_entry_buffer_get_bytes (get_buffer (entry)) == old_n_bytes)
: PROP_GICON_SECONDARY]);
break;
+ case GTK_IMAGE_EMPTY:
+ case GTK_IMAGE_ANIMATION:
+ case GTK_IMAGE_SURFACE:
default:
g_assert_not_reached ();
break;
case GDK_SCROLL_RIGHT:
dx += 1;
break;
+ case GDK_SCROLL_SMOOTH:
default:
g_assert_not_reached ();
break;
return FALSE;
}
case FOCUS_NONE:
+ default:
break;
}
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_DOWN:
case GTK_DIR_RIGHT:
+ default:
return FOCUS_WIDGET;
}
break;
return ltr ? FOCUS_NONE : FOCUS_LABEL;
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_DOWN:
+ default:
return FOCUS_LABEL;
case GTK_DIR_RIGHT:
return ltr ? FOCUS_LABEL : FOCUS_NONE;
return ltr ? FOCUS_WIDGET : FOCUS_CHILD;
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_DOWN:
+ default:
return FOCUS_CHILD;
case GTK_DIR_RIGHT:
return ltr ? FOCUS_CHILD : FOCUS_WIDGET;
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_DOWN:
case GTK_DIR_RIGHT:
+ default:
return FOCUS_NONE;
}
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
-
- g_assert_not_reached ();
+
return FOCUS_NONE;
}
g_value_set_enum ((GValue *) value, GTK_FILE_CHOOSER_ACTION_OPEN);
}
break;
+ default:
+ break;
}
g_object_set_property (G_OBJECT (priv->chooser), pspec->name, value);
case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
return gtk_widget_mnemonic_activate (priv->combo_box, group_cycling);
break;
+ case GTK_FILE_CHOOSER_ACTION_SAVE:
+ case GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER:
default:
g_assert_not_reached ();
break;
break;
case GTK_FILE_CHOOSER_ACTION_SAVE:
case GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER:
+ default:
gtk_entry_completion_set_inline_completion (completion, FALSE);
break;
}
{
case GTK_FILE_CHOOSER_ACTION_OPEN:
case GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER:
+ default:
gtk_entry_completion_set_popup_single_match (comp, FALSE);
break;
case GTK_FILE_CHOOSER_ACTION_SAVE:
case MODE_PORTAL:
gtk_file_chooser_native_portal_hide (self);
break;
+ default:
+ break;
}
}
case SAVE_ENTRY:
goto save_entry;
+ case NOT_REACHED:
default:
g_assert_not_reached ();
}
}
break;
}
+ default:
+ break;
}
}
if (rule->u.custom.func (filter_info, rule->u.custom.data))
return TRUE;
break;
+
+ default:
+ break;
}
}
/* FIXME: use freeze/thaw with this somehow? */
case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
case G_FILE_MONITOR_EVENT_UNMOUNTED:
+ case G_FILE_MONITOR_EVENT_MOVED:
+ case G_FILE_MONITOR_EVENT_RENAMED:
+ case G_FILE_MONITOR_EVENT_MOVED_IN:
+ case G_FILE_MONITOR_EVENT_MOVED_OUT:
default:
/* ignore these */
break;
case GTK_ALIGN_END:
offset = pixels;
break;
+ case GTK_ALIGN_BASELINE:
default:
g_assert_not_reached ();
break;
case GTK_SCROLL_PAGE_BACKWARD:
factor = - AUTOSCROLL_FACTOR_FAST;
break;
+ case GTK_SCROLL_NONE:
+ case GTK_SCROLL_JUMP:
+ case GTK_SCROLL_STEP_UP:
+ case GTK_SCROLL_STEP_DOWN:
+ case GTK_SCROLL_STEP_LEFT:
+ case GTK_SCROLL_STEP_RIGHT:
+ case GTK_SCROLL_PAGE_UP:
+ case GTK_SCROLL_PAGE_DOWN:
+ case GTK_SCROLL_PAGE_LEFT:
+ case GTK_SCROLL_PAGE_RIGHT:
+ case GTK_SCROLL_START:
+ case GTK_SCROLL_END:
default:
g_assert_not_reached ();
+ break;
}
increment = gtk_adjustment_get_step_increment (adjustment) / factor;
if (vertical)
{
- switch (step)
+ switch ((guint) step)
{
case GTK_MOVEMENT_VISUAL_POSITIONS:
step = GTK_MOVEMENT_DISPLAY_LINES;
case GTK_MOVEMENT_DISPLAY_LINES:
step = GTK_MOVEMENT_VISUAL_POSITIONS;
break;
- default: ;
+ default:
+ break;
}
}
child = NULL;
- switch (step)
+ switch ((guint) step)
{
case GTK_MOVEMENT_VISUAL_POSITIONS:
if (priv->cursor_child != NULL)
case PANGO_STYLE_ITALIC:
g_string_append (s, "font-style: italic; ");
break;
+ default:
+ break;
}
}
if (set & PANGO_FONT_MASK_VARIANT)
case PANGO_VARIANT_SMALL_CAPS:
g_string_append (s, "font-variant: small-caps; ");
break;
+ default:
+ break;
}
}
if (set & PANGO_FONT_MASK_WEIGHT)
case PANGO_WEIGHT_ULTRAHEAVY:
g_string_append (s, "font-weight: 900; ");
break;
+ default:
+ break;
}
}
if (set & PANGO_FONT_MASK_STRETCH)
case PANGO_STRETCH_ULTRA_EXPANDED:
g_string_append (s, "font-stretch: ultra-expanded; ");
break;
+ default:
+ break;
}
}
if (set & PANGO_FONT_MASK_SIZE)
while (g_hash_table_iter_next (&iter, (gpointer*) &seq, (gpointer*) &data))
{
- switch (gdk_event_get_event_type (data->event))
+ switch ((guint) gdk_event_get_event_type (data->event))
{
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_UPDATE:
event_type = gdk_event_get_event_type (event);
- switch (event_type)
+ switch ((guint) event_type)
{
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_END:
line->natural_above += line->natural - (line->natural_above + line->natural_below);
line->natural_below += 0;
break;
+ default:
+ break;
}
}
}
line->allocated_baseline =
line->allocation - line->minimum_below;
break;
+ default:
+ break;
}
}
else
scale));
break;
+ case GTK_IMAGE_EMPTY:
+ case GTK_IMAGE_ICON_NAME:
+ case GTK_IMAGE_GICON:
+ case GTK_IMAGE_SURFACE:
default:
break;
}
{
case ICON_THEME_DIR_FIXED:
return abs (scaled_size - scaled_dir_size);
- break;
+
case ICON_THEME_DIR_SCALABLE:
if (scaled_size < (dir->min_size * dir->scale))
return (dir->min_size * dir->scale) - scaled_size;
if (size > (dir->max_size * dir->scale))
return scaled_size - (dir->max_size * dir->scale);
return 0;
- break;
+
case ICON_THEME_DIR_THRESHOLD:
min = (dir->size - dir->threshold) * dir->scale;
max = (dir->size + dir->threshold) * dir->scale;
if (scaled_size > max)
return scaled_size - max;
return 0;
- break;
+
case ICON_THEME_DIR_UNTHEMED:
+ default:
g_assert_not_reached ();
- break;
+ return 1000;
}
- g_assert_not_reached ();
- return 1000;
}
static const gchar *
return ".png";
case ICON_SUFFIX_SYMBOLIC_PNG:
return ".symbolic.png";
+ case ICON_SUFFIX_NONE:
+ case HAS_ICON_FILE:
default:
g_assert_not_reached();
+ return NULL;
}
- return NULL;
}
static IconSuffix
x = 0;
y = 0;
break;
+ default:
+ break;
}
if (icon == NULL)
rect.y = dest_item->cell_area.y;
rect.width = 2;
rect.height = dest_item->cell_area.height;
- case GTK_ICON_VIEW_NO_DROP: ;
+ case GTK_ICON_VIEW_NO_DROP:
+ default:
break;
}
switch (icon_view->priv->selection_mode)
{
case GTK_SELECTION_NONE:
+ default:
break;
case GTK_SELECTION_BROWSE:
_gtk_icon_view_select_item (icon_view, icon_view->priv->cursor_item);
case GTK_MOVEMENT_BUFFER_ENDS:
gtk_icon_view_move_cursor_start_end (icon_view, count);
break;
+ case GTK_MOVEMENT_WORDS:
+ case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
+ case GTK_MOVEMENT_PARAGRAPHS:
+ case GTK_MOVEMENT_PARAGRAPH_ENDS:
+ case GTK_MOVEMENT_HORIZONTAL_PAGES:
default:
g_assert_not_reached ();
+ break;
}
icon_view->priv->modify_selection_pressed = FALSE;
case GTK_IMAGE_GICON:
g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_GICON]);
break;
+ case GTK_IMAGE_SURFACE:
+ g_object_notify_by_pspec (G_OBJECT (image), image_props[PROP_SURFACE]);
+ break;
case GTK_IMAGE_EMPTY:
default:
break;
}
case GTK_KINETIC_SCROLLING_PHASE_FINISHED:
+ default:
break;
}
break;
default:
+ case GTK_DIR_UP:
+ case GTK_DIR_DOWN:
+ case GTK_DIR_LEFT:
+ case GTK_DIR_RIGHT:
goto out;
}
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PAGES:
case GTK_MOVEMENT_HORIZONTAL_PAGES:
+ default:
break;
}
}
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PAGES:
case GTK_MOVEMENT_HORIZONTAL_PAGES:
+ default:
break;
}
}
if (next_focus_row == NULL)
next_focus_row = gtk_list_box_get_last_focusable (box);
break;
+ case GTK_DIR_DOWN:
+ case GTK_DIR_TAB_FORWARD:
+ case GTK_DIR_LEFT:
+ case GTK_DIR_RIGHT:
default:
next_focus_row = priv->selected_row;
if (next_focus_row == NULL)
int height;
row = NULL;
- switch (step)
+ switch ((guint) step)
{
case GTK_MOVEMENT_BUFFER_ENDS:
if (count < 0)
{
event = gdk_event_copy (event);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_SCROLL:
rewrite_events_translate (event->any.window,
GdkDisplay *display;
GdkDevice *device;
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_SCROLL:
case GDK_BUTTON_PRESS:
return GDK_NOTIFY_VIRTUAL;
case GDK_NOTIFY_NONLINEAR:
return GDK_NOTIFY_NONLINEAR_VIRTUAL;
+ case GDK_NOTIFY_VIRTUAL:
+ case GDK_NOTIFY_NONLINEAR_VIRTUAL:
+ case GDK_NOTIFY_UNKNOWN:
default:
g_assert_not_reached ();
return GDK_NOTIFY_UNKNOWN;
static gboolean
is_pointing_event (GdkEvent *event)
{
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_MOTION_NOTIFY:
case GDK_ENTER_NOTIFY:
sequence = gdk_event_get_event_sequence (event);
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_LEAVE_NOTIFY:
if (event->crossing.mode == GDK_CROSSING_GRAB ||
case GDK_DROP_START:
_gtk_drag_dest_handle_event (event_widget, event);
break;
+ case GDK_SETTING:
+ case GDK_OWNER_CHANGE:
+ case GDK_EVENT_LAST:
default:
g_assert_not_reached ();
break;
g_object_ref (window);
g_object_ref (menu);
- switch (gdk_event_get_event_type (event))
+ switch ((guint) gdk_event_get_event_type (event))
{
case GDK_WINDOW_STATE:
/* Window for the menu has been closed by the display server or by GDK.
source_device = gdk_event_get_source_device (event);
gdk_event_get_root_coords (event, &x_root, &y_root);
- switch (gdk_event_get_event_type (event))
+ switch ((guint) gdk_event_get_event_type (event))
{
case GDK_TOUCH_BEGIN:
case GDK_BUTTON_PRESS:
return GDK_GRAVITY_SOUTH;
case GDK_GRAVITY_SOUTH_EAST:
return GDK_GRAVITY_SOUTH_WEST;
+ default:
+ g_warning ("unknown GdkGravity: %d", anchor);
+ return anchor;
}
-
- g_warning ("unknown GdkGravity: %d", anchor);
- return anchor;
}
static void
case GTK_MENU_DIR_PARENT:
direction = GTK_MENU_DIR_CHILD;
break;
- default: ;
+ case GTK_MENU_DIR_NEXT:
+ case GTK_MENU_DIR_PREV:
+ default:
+ break;
}
}
gint end_position = get_menu_height (menu);
GtkMenuShell *menu_shell = GTK_MENU_SHELL (menu);
- switch (type)
+ switch ((guint) type)
{
case GTK_SCROLL_PAGE_UP:
case GTK_SCROLL_PAGE_DOWN:
case GTK_MENU_DIR_NEXT:
direction = GTK_MENU_DIR_PREV;
break;
- default: ;
+ case GTK_MENU_DIR_PARENT:
+ case GTK_MENU_DIR_CHILD:
+ default:
+ break;
}
}
}
switch (gtk_widget_get_halign (priv->menu))
{
+ default:
case GTK_ALIGN_FILL:
case GTK_ALIGN_START:
case GTK_ALIGN_BASELINE:
switch (gtk_widget_get_halign (priv->menu))
{
+ default:
case GTK_ALIGN_FILL:
case GTK_ALIGN_START:
case GTK_ALIGN_BASELINE:
switch (gtk_widget_get_valign (priv->menu))
{
+ default:
case GTK_ALIGN_FILL:
case GTK_ALIGN_START:
case GTK_ALIGN_BASELINE:
switch (gtk_widget_get_valign (priv->menu))
{
+ default:
case GTK_ALIGN_FILL:
case GTK_ALIGN_START:
case GTK_ALIGN_BASELINE:
NULL);
break;
+
+ default:
+ break;
}
gtk_menu_popup_at_widget (GTK_MENU (priv->menu),
case GTK_ARROW_RIGHT:
gtk_image_set_from_icon_name (image, "pan-end-symbolic", GTK_ICON_SIZE_BUTTON);
break;
+ default:
+ break;
}
}
case GTK_ARROW_RIGHT:
gtk_popover_set_position (GTK_POPOVER (priv->popover), GTK_POS_RIGHT);
break;
+ default:
+ break;
}
}
break;
case GTK_DIRECTION_RIGHT:
+ default:
menu_item->priv->submenu_direction = GTK_DIRECTION_LEFT;
break;
}
break;
case GTK_LEFT_RIGHT:
+ default:
if (parent_menu && GTK_IS_MENU_ITEM (parent_menu->priv->parent_menu_item))
submenu_direction = GTK_MENU_ITEM (parent_menu->priv->parent_menu_item)->priv->submenu_direction;
else
switch (submenu_direction)
{
case GTK_DIRECTION_RIGHT:
+ default:
g_object_set (priv->submenu,
"rect-anchor-dx", horizontal_offset + parent_padding.right + menu_padding.left,
NULL);
if (!had_selection && !priv->active_menu_item && priv->children)
gtk_menu_shell_select_first (menu_shell, TRUE);
break;
+
+ default:
+ break;
}
}
if (list)
gtk_notebook_switch_focus_tab (notebook, list);
break;
+
+ default:
+ break;
}
return TRUE;
tab_width = MAX (tab_width, page->requisition.width);
tab_max = MAX (tab_max, page->requisition.height);
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
else if (gtk_widget_get_visible (page->tab_label))
if (allocation.x + allocation.width / 2 < x)
return children;
}
-
break;
+
case GTK_POS_LEFT:
case GTK_POS_RIGHT:
if (allocation.y + allocation.height / 2 > y)
return children;
+ break;
+ default:
+ g_assert_not_reached ();
break;
}
if (old_focus_child == priv->action_widget[ACTION_WIDGET_START])
{
- switch (effective_direction)
+ switch ((guint) effective_direction)
{
case GTK_DIR_DOWN:
return focus_child_in (notebook, GTK_DIR_TAB_FORWARD);
case GTK_DIR_UP:
return FALSE;
default:
- switch (direction)
+ switch ((guint) direction)
{
case GTK_DIR_TAB_FORWARD:
if ((priv->tab_pos == GTK_POS_RIGHT || priv->tab_pos == GTK_POS_BOTTOM) &&
return FALSE;
default:
g_assert_not_reached ();
+ break;
}
}
}
else if (old_focus_child == priv->action_widget[ACTION_WIDGET_END])
{
- switch (effective_direction)
+ switch ((guint) effective_direction)
{
case GTK_DIR_DOWN:
return focus_child_in (notebook, GTK_DIR_TAB_FORWARD);
case GTK_DIR_UP:
return FALSE;
default:
- switch (direction)
+ switch ((guint) direction)
{
case GTK_DIR_TAB_FORWARD:
return FALSE;
return focus_tabs_in (notebook);
default:
g_assert_not_reached ();
+ break;
}
}
}
else
{
- switch (effective_direction)
+ switch ((guint) effective_direction)
{
case GTK_DIR_TAB_BACKWARD:
case GTK_DIR_UP:
return FALSE;
case GTK_DIR_TAB_FORWARD:
return focus_action_in (notebook, last_action, direction);
+ default:
+ break;
}
}
}
else if (widget_is_focus) /* Focus was on tabs */
{
- switch (effective_direction)
+ switch ((guint) effective_direction)
{
case GTK_DIR_TAB_BACKWARD:
return focus_action_in (notebook, first_action, direction);
return focus_tabs_move (notebook, direction, STEP_PREV);
case GTK_DIR_RIGHT:
return focus_tabs_move (notebook, direction, STEP_NEXT);
+ default:
+ break;
}
}
else /* Focus was not on widget */
{
- switch (effective_direction)
+ switch ((guint) effective_direction)
{
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_DOWN:
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
return focus_child_in (notebook, direction);
+ default:
+ break;
}
}
case GTK_POS_RIGHT:
step = STEP_PREV;
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
}
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
*tab_space += page->requisition.height;
}
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
if (!priv->scrollable)
*tab_space = tabs_allocation->height;
}
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
}
}
else
return (search_direction == STEP_NEXT);
- break;
case GTK_POS_RIGHT:
case GTK_POS_LEFT:
return (search_direction == STEP_PREV);
- break;
- }
- return FALSE;
+ default:
+ g_assert_not_reached ();
+ return FALSE;
+ }
}
static void
widget = GTK_WIDGET (notebook);
tab_pos = get_effective_tab_pos (notebook);
allocate_at_bottom = get_allocate_at_bottom (widget, direction);
- anchor = 0;
child_allocation = *allocation;
child_allocation.y += allocation->height;
anchor = child_allocation.y;
break;
+
+ default:
+ g_assert_not_reached ();
+ anchor = 0;
+ break;
}
gtk_widget_get_own_allocation (priv->cur_page->tab_widget, &drag_allocation);
child_allocation.y = anchor;
}
+ break;
+ default:
+ g_assert_not_reached ();
break;
}
}
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
(allocate_at_bottom && priv->drag_window_y < anchor))
priv->drag_window_y = anchor;
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
}
children = children->prev;
}
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
{
GtkNotebookPrivate *priv = notebook->priv;
GtkNotebookPage *page;
- GtkDirectionType dir = GTK_DIR_DOWN; /* Quiet GCC */
+ GtkDirectionType dir;
GtkPositionType tab_pos = get_effective_tab_pos (notebook);
if (!priv->focus_tab)
case GTK_POS_RIGHT:
dir = GTK_DIR_LEFT;
break;
+ default:
+ g_assert_not_reached ();
+ dir = GTK_DIR_DOWN;
+ break;
}
if (gtk_widget_child_focus (page->child, dir))
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->box), GTK_ORIENTATION_HORIZONTAL);
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->header_widget), GTK_ORIENTATION_VERTICAL);
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
update_node_ordering (notebook);
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_END : GTK_ALIGN_START;
case GTK_ALIGN_END:
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_START : GTK_ALIGN_END;
+ case GTK_ALIGN_FILL:
+ case GTK_ALIGN_CENTER:
+ case GTK_ALIGN_BASELINE:
default:
return align;
}
return GDK_EVENT_PROPAGATE;
}
- switch (event_type)
+ switch ((guint) event_type)
{
case GDK_PAD_BUTTON_PRESS:
type = GTK_PAD_ACTION_BUTTON;
case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (priv->reverse_landscape_radio), TRUE);
break;
+ default:
+ break;
}
}
new_position = priv->max_position;
break;
+ case GTK_SCROLL_NONE:
+ case GTK_SCROLL_JUMP:
default:
break;
}
start_index = 0;
end_index = prev_line->start_index + prev_line->length;
break;
+ case ATK_TEXT_BOUNDARY_CHAR:
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ case ATK_TEXT_BOUNDARY_SENTENCE_START:
+ case ATK_TEXT_BOUNDARY_SENTENCE_END:
default:
g_assert_not_reached();
+ break;
}
}
else
if (prev_line)
start_index = prev_line->start_index + prev_line->length;
break;
+ case ATK_TEXT_BOUNDARY_CHAR:
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ case ATK_TEXT_BOUNDARY_SENTENCE_START:
+ case ATK_TEXT_BOUNDARY_SENTENCE_END:
default:
g_assert_not_reached();
+ break;
}
found = TRUE;
start_index = end_index;
end_index = line->start_index + line->length;
break;
+ case ATK_TEXT_BOUNDARY_CHAR:
+ case ATK_TEXT_BOUNDARY_WORD_START:
+ case ATK_TEXT_BOUNDARY_WORD_END:
+ case ATK_TEXT_BOUNDARY_SENTENCE_START:
+ case ATK_TEXT_BOUNDARY_SENTENCE_END:
default:
g_assert_not_reached();
+ break;
}
}
else
case ATK_TEXT_BOUNDARY_LINE_END:
pango_layout_get_line_before (layout, boundary_type, offset, &start, &end);
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
*start_offset = start;
case ATK_TEXT_BOUNDARY_LINE_END:
pango_layout_get_line_after (layout, boundary_type, offset, &start, &end);
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
*start_offset = start;
case ATK_TEXT_BOUNDARY_LINE_END:
pango_layout_get_line_at (layout, boundary_type, offset, &start, &end);
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
*start_offset = start;
g_set_object (&data->path_bar->priv->desktop_icon, icon);
break;
+ case NORMAL_BUTTON:
+ case ROOT_BUTTON:
default:
break;
};
set_button_image_get_info_cb,
data);
break;
+
+ case NORMAL_BUTTON:
default:
break;
}
ICON_CASE (TEMPLATES);
ICON_CASE (VIDEOS);
+ case G_USER_N_DIRECTORIES:
default:
return g_themed_icon_new_with_default_fallbacks (ICON_NAME_FOLDER);
}
case GTK_POS_RIGHT:
rect.x -= priv->transition_diff;
break;
+ default:
+ break;
}
_gtk_window_set_popover_position (priv->window, widget,
child_alloc.x += TAIL_HEIGHT;
child_alloc.y += TAIL_HEIGHT / 2;
break;
+ default:
+ break;
}
gtk_widget_size_allocate (priv->contents_widget, &child_alloc, -1, out_clip);
case GTK_PRINTER_OPTION_TYPE_PICKONE_REAL:
filtered_val = filter_numeric (value, TRUE, TRUE, &changed);
break;
+ case GTK_PRINTER_OPTION_TYPE_BOOLEAN:
+ case GTK_PRINTER_OPTION_TYPE_PICKONE:
+ case GTK_PRINTER_OPTION_TYPE_PICKONE_PASSWORD:
+ case GTK_PRINTER_OPTION_TYPE_PICKONE_STRING:
+ case GTK_PRINTER_OPTION_TYPE_ALTERNATIVE:
+ case GTK_PRINTER_OPTION_TYPE_STRING:
+ case GTK_PRINTER_OPTION_TYPE_FILESAVE:
+ case GTK_PRINTER_OPTION_TYPE_INFO:
default:
break;
}
case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
cairo_ps_surface_dsc_comment (op_portal->surface, "%%PageOrientation: Landscape");
break;
+
+ default:
+ break;
}
}
else if (type == CAIRO_SURFACE_TYPE_PDF)
case GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE:
cairo_ps_surface_dsc_comment (op_unix->surface, "%%PageOrientation: Landscape");
break;
+ default:
+ break;
}
}
else if (type == CAIRO_SURFACE_TYPE_PDF)
return TRUE;
}
return FALSE;
+ default:
+ return FALSE;
}
- return FALSE;
}
static void
return len;
case GTK_UNIT_INCH:
return len * MM_PER_INCH;
+ case GTK_UNIT_NONE:
default:
g_warning ("Unsupported unit");
/* Fall through */
return len;
case GTK_UNIT_INCH:
return len / MM_PER_INCH;
+ case GTK_UNIT_NONE:
default:
g_warning ("Unsupported unit");
/* Fall through */
step = gtk_adjustment_get_step_increment (adj);
page = gtk_adjustment_get_page_increment (adj);
- switch (priv->autoscroll_mode)
+ switch ((guint) priv->autoscroll_mode)
{
case GTK_SCROLL_STEP_FORWARD:
increment = step / AUTOSCROLL_FACTOR;
break;
case GTK_SCROLL_NONE:
+ default:
break;
}
if (rule->u.custom.func (filter_info, rule->u.custom.data))
return TRUE;
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
gdk_threads_leave ();
break;
+ case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
+ case G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED:
+ case G_FILE_MONITOR_EVENT_PRE_UNMOUNT:
+ case G_FILE_MONITOR_EVENT_UNMOUNTED:
+ case G_FILE_MONITOR_EVENT_MOVED:
+ case G_FILE_MONITOR_EVENT_RENAMED:
+ case G_FILE_MONITOR_EVENT_MOVED_IN:
+ case G_FILE_MONITOR_EVENT_MOVED_OUT:
+
default:
break;
}
wc = border_width;
hc = MAX (xy1_gap - xy0_gap - 2 * border_width, 0);
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
cairo_clip_extents (cr, &x0, &y0, &x1, &y1);
switch (transition)
{
- case GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT:
+ case GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT:
child_allocation->x = - child_allocation->width * (1 - priv->current_pos);
break;
- case GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN:
+ case GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN:
child_allocation->y = - child_allocation->height * (1 - priv->current_pos);
break;
- default: {}
+ case GTK_REVEALER_TRANSITION_TYPE_NONE:
+ case GTK_REVEALER_TRANSITION_TYPE_CROSSFADE:
+ case GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT:
+ case GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP:
+ default:
+ break;
}
}
case GTK_POS_BOTTOM:
border->bottom += value_size;
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
case GTK_SCROLL_START:
case GTK_SCROLL_END:
break;
+ case GTK_SCROLL_NONE:
+ case GTK_SCROLL_JUMP:
default:
g_warning ("Invalid scroll type %u for GtkScrolledWindow::scroll-child", scroll);
return FALSE;
case GTK_SCROLL_END:
value = gtk_adjustment_get_upper (adjustment);
break;
+ case GTK_SCROLL_STEP_UP:
+ case GTK_SCROLL_STEP_DOWN:
+ case GTK_SCROLL_STEP_LEFT:
+ case GTK_SCROLL_STEP_RIGHT:
+ case GTK_SCROLL_PAGE_UP:
+ case GTK_SCROLL_PAGE_DOWN:
+ case GTK_SCROLL_PAGE_LEFT:
+ case GTK_SCROLL_PAGE_RIGHT:
+ case GTK_SCROLL_NONE:
+ case GTK_SCROLL_JUMP:
default:
g_assert_not_reached ();
break;
case PROP_CURSOR_THEME_SIZE:
settings_update_cursor_theme (settings);
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
icon = g_themed_icon_new ("gesture-swipe-right-symbolic");
break;
- default: ;
+ case GTK_SHORTCUT_ACCELERATOR:
+ case GTK_SHORTCUT_GESTURE:
+ default:
icon = NULL;
break;
}
break;
}
+ case GTK_SCROLL_NONE:
+ case GTK_SCROLL_JUMP:
default:
g_warning ("Invalid scroll type %d for GtkSpinButton::change-value", scroll);
break;
return new_child_first ? GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT : GTK_STACK_TRANSITION_TYPE_OVER_LEFT;
case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT:
return new_child_first ? GTK_STACK_TRANSITION_TYPE_UNDER_LEFT : GTK_STACK_TRANSITION_TYPE_OVER_RIGHT;
- default: ;
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_UP:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_OVER_UP:
+ case GTK_STACK_TRANSITION_TYPE_OVER_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_UNDER_UP:
+ case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_NONE:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT:
+ case GTK_STACK_TRANSITION_TYPE_OVER_LEFT:
+ case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT:
+ case GTK_STACK_TRANSITION_TYPE_UNDER_LEFT:
+ case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
+ case GTK_STACK_TRANSITION_TYPE_CROSSFADE:
+ default:
+ return transition_type;
}
- return transition_type;
}
static gint
return GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT;
case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
return GTK_STACK_TRANSITION_TYPE_UNDER_LEFT;
- default: ;
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_UP:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_OVER_UP:
+ case GTK_STACK_TRANSITION_TYPE_OVER_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_UNDER_UP:
+ case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_NONE:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP:
+ case GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT:
+ case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT:
+ case GTK_STACK_TRANSITION_TYPE_CROSSFADE:
+ default:
+ return transition_type;
}
}
-
- return transition_type;
+ else
+ {
+ return transition_type;
+ }
}
static void
pos_x = pos_y = 0;
- switch (priv->active_transition_type)
+ switch ((guint) priv->active_transition_type)
{
case GTK_STACK_TRANSITION_TYPE_UNDER_DOWN:
y = 0;
x = get_bin_window_x (stack);
y = get_bin_window_y (stack);
- switch (priv->active_transition_type)
+ switch ((guint) priv->active_transition_type)
{
case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT:
x -= width;
case GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT:
gtk_stack_snapshot_under (widget, snapshot);
break;
+ case GTK_STACK_TRANSITION_TYPE_NONE:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT:
+ case GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN:
+ case GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP:
+ case GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT:
+ case GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT:
default:
g_assert_not_reached ();
}
gtk_text_iter_forward_to_line_end (end);
}
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
}
}
gtk_text_iter_forward_to_line_end (end);
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
}
gtk_text_iter_forward_to_line_end (end);
}
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
}
attribute_names, attribute_values,
info, error);
break;
+ case STATE_ATTR:
+ case STATE_PIXBUF:
default:
g_assert_not_reached ();
break;
g_assert (peek_state (info) == STATE_APPLY_TAG ||
peek_state (info) == STATE_TEXT);
break;
+ case STATE_START:
default:
g_assert_not_reached ();
break;
peek_state (info) != STATE_APPLY_TAG)
return;
- switch (peek_state (info))
+ if (peek_state (info) == STATE_TEXT ||
+ peek_state (info) == STATE_APPLY_TAG)
{
- case STATE_START:
- g_assert_not_reached (); /* gmarkup shouldn't do this */
- break;
- case STATE_TEXT:
- case STATE_APPLY_TAG:
if (text_len == 0)
return;
span->tags = g_slist_copy (info->tag_stack);
info->spans = g_list_prepend (info->spans, span);
- break;
- default:
- g_assert_not_reached ();
- break;
}
}
case PANGO_DIRECTION_RTL :
display->direction = GTK_TEXT_DIR_RTL;
break;
+ case PANGO_DIRECTION_LTR:
+ case PANGO_DIRECTION_TTB_LTR:
+ case PANGO_DIRECTION_TTB_RTL:
+ case PANGO_DIRECTION_WEAK_LTR:
+ case PANGO_DIRECTION_WEAK_RTL:
default:
display->direction = GTK_TEXT_DIR_LTR;
break;
break;
case GTK_WRAP_NONE:
+ default:
break;
}
PangoAttribute *attr = tmp_list->data;
GdkRGBA rgba;
- switch (attr->klass->type)
+ switch ((guint) attr->klass->type)
{
case PANGO_ATTR_FOREGROUND:
convert_color (&rgba, (PangoAttrColor *)attr);
switch (pango_layout_get_alignment (display->layout))
{
case PANGO_ALIGN_LEFT:
+ default:
break;
case PANGO_ALIGN_CENTER:
display->x_offset += excess / 2;
return PANGO_FONT_MASK_STRETCH;
case PROP_SIZE_SET:
return PANGO_FONT_MASK_SIZE;
+ default:
+ return 0;
}
-
- return 0;
}
static PangoFontMask
g_value_get_double (value) * PANGO_SCALE);
g_object_notify (object, "size");
break;
+
+ default:
+ break;
}
size_changed = TRUE;
break;
case PROP_FAMILY:
+ gtk_text_tag_ensure_font (tag);
+ g_value_set_string (value, pango_font_description_get_family (priv->values->font));
+ break;
+
case PROP_STYLE:
+ gtk_text_tag_ensure_font (tag);
+ g_value_set_enum (value, pango_font_description_get_style (priv->values->font));
+ break;
+
case PROP_VARIANT:
+ gtk_text_tag_ensure_font (tag);
+ g_value_set_enum (value, pango_font_description_get_variant (priv->values->font));
+ break;
+
case PROP_WEIGHT:
+ gtk_text_tag_ensure_font (tag);
+ g_value_set_int (value, pango_font_description_get_weight (priv->values->font));
+ break;
+
case PROP_STRETCH:
+ gtk_text_tag_ensure_font (tag);
+ g_value_set_enum (value, pango_font_description_get_stretch (priv->values->font));
+ break;
+
case PROP_SIZE:
- case PROP_SIZE_POINTS:
gtk_text_tag_ensure_font (tag);
- switch (prop_id)
- {
- case PROP_FAMILY:
- g_value_set_string (value, pango_font_description_get_family (priv->values->font));
- break;
-
- case PROP_STYLE:
- g_value_set_enum (value, pango_font_description_get_style (priv->values->font));
- break;
-
- case PROP_VARIANT:
- g_value_set_enum (value, pango_font_description_get_variant (priv->values->font));
- break;
-
- case PROP_WEIGHT:
- g_value_set_int (value, pango_font_description_get_weight (priv->values->font));
- break;
-
- case PROP_STRETCH:
- g_value_set_enum (value, pango_font_description_get_stretch (priv->values->font));
- break;
-
- case PROP_SIZE:
- g_value_set_int (value, pango_font_description_get_size (priv->values->font));
- break;
-
- case PROP_SIZE_POINTS:
- g_value_set_double (value, ((double)pango_font_description_get_size (priv->values->font)) / (double)PANGO_SCALE);
- break;
- }
+ g_value_set_int (value, pango_font_description_get_size (priv->values->font));
break;
+ case PROP_SIZE_POINTS:
+ gtk_text_tag_ensure_font (tag);
+ g_value_set_double (value, ((double)pango_font_description_get_size (priv->values->font)) / (double)PANGO_SCALE);
+ break;
+
case PROP_SCALE:
g_value_set_double (value, priv->values->font_scale);
break;
gdouble event_x, event_y;
if (event)
- switch (gdk_event_get_event_type (event))
+ switch ((guint) gdk_event_get_event_type (event))
{
case GDK_MOTION_NOTIFY:
case GDK_BUTTON_PRESS:
gtk_text_buffer_get_iter_at_offset (get_buffer (text_view), &newplace, 0);
break;
+ case GTK_MOVEMENT_PAGES:
+ case GTK_MOVEMENT_HORIZONTAL_PAGES:
default:
break;
}
case GTK_TEXT_WINDOW_BOTTOM:
gtk_css_node_add_class (win->css_node, g_quark_from_static_string (GTK_STYLE_CLASS_BOTTOM));
break;
- default: /* no extra style class */ ;
+ case GTK_TEXT_WINDOW_PRIVATE:
+ case GTK_TEXT_WINDOW_WIDGET:
+ case GTK_TEXT_WINDOW_TEXT:
+ default:
+ /* no extra style class */
+ break;
}
}
g_object_unref (win->css_node);
gdk_window_show (win->bin_window);
- switch (win->type)
+ if (win->type == GTK_TEXT_WINDOW_TEXT &&
+ gtk_widget_is_sensitive (widget))
{
- case GTK_TEXT_WINDOW_TEXT:
- if (gtk_widget_is_sensitive (widget))
- {
- display = gdk_window_get_display (window);
- cursor = gdk_cursor_new_from_name (display, "text");
- gdk_window_set_cursor (win->bin_window, cursor);
- g_clear_object (&cursor);
- }
+ display = gdk_window_get_display (window);
+ cursor = gdk_cursor_new_from_name (display, "text");
+ gdk_window_set_cursor (win->bin_window, cursor);
+ g_clear_object (&cursor);
gtk_im_context_set_client_widget (GTK_TEXT_VIEW (widget)->priv->im_context,
widget);
- break;
- default:
- break;
}
g_object_set_qdata (G_OBJECT (win->window),
window_rect.height = win->allocation.height;
break;
+ case GTK_TEXT_WINDOW_PRIVATE:
+ case GTK_TEXT_WINDOW_WIDGET:
default:
g_warning ("%s: bug!", G_STRFUNC);
return;
break;
case GTK_TEXT_WINDOW_PRIVATE:
+ default:
g_warning ("%s: You can't get GTK_TEXT_WINDOW_PRIVATE, it has \"PRIVATE\" in the name because it is private.", G_STRFUNC);
return NULL;
break;
return priv->bottom_window->css_node;
break;
+ case GTK_TEXT_WINDOW_PRIVATE:
default:
break;
}
&priv->bottom_window);
break;
+ case GTK_TEXT_WINDOW_PRIVATE:
+ case GTK_TEXT_WINDOW_WIDGET:
+ case GTK_TEXT_WINDOW_TEXT:
default:
g_warning ("Can only set size of left/right/top/bottom border windows with gtk_text_view_set_border_window_size()");
break;
return priv->bottom_window->requisition.height;
break;
+ case GTK_TEXT_WINDOW_PRIVATE:
+ case GTK_TEXT_WINDOW_WIDGET:
+ case GTK_TEXT_WINDOW_TEXT:
default:
g_warning ("Can only get size of left/right/top/bottom border windows with gtk_text_view_get_border_window_size()");
break;
(GdkEvent *) event);
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
}
switch (style)
{
+ default:
case GTK_TOOLBAR_ICONS:
if (icon)
gtk_container_add (GTK_CONTAINER (button->priv->button), icon);
gtk_label_set_ellipsize (GTK_LABEL (label_widget), priv->ellipsize);
}
break;
+
+ default:
+ g_assert_not_reached ();
+ break;
}
gtk_widget_set_margin_start (frame, dx);
return;
}
- switch (event_type)
+ switch ((guint) event_type)
{
case GDK_BUTTON_PRESS:
case GDK_KEY_PRESS:
&end_node);
anchor_path = start_path;
break;
+ default:
+ g_assert_not_reached ();
+ break;
}
/* Invalid start or end node? */
case GTK_TREE_VIEW_DROP_INTO_OR_AFTER:
gtk_style_context_add_class (context, "into");
break;
+
+ default:
+ break;
}
_gtk_tree_view_find_node (tree_view, drag_dest_path, &drag_tree, &drag_node);
else
return (GtkTreeViewColumn *)0x1;
break;
- }
- return (GtkTreeViewColumn *)0x1;
+ default:
+ return (GtkTreeViewColumn *)0x1;
+ break;
+ }
}
static gboolean
case GTK_MOVEMENT_BUFFER_ENDS:
gtk_tree_view_move_cursor_start_end (tree_view, count);
break;
+ case GTK_MOVEMENT_WORDS:
+ case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
+ case GTK_MOVEMENT_PARAGRAPHS:
+ case GTK_MOVEMENT_PARAGRAPH_ENDS:
+ case GTK_MOVEMENT_HORIZONTAL_PAGES:
default:
g_assert_not_reached ();
}
if (priv->clickable == FALSE)
{
- switch (event_type)
+ switch ((guint) event_type)
{
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_END : GTK_ALIGN_START;
case GTK_ALIGN_END:
return direction == GTK_TEXT_DIR_RTL ? GTK_ALIGN_START : GTK_ALIGN_END;
+ case GTK_ALIGN_FILL:
+ case GTK_ALIGN_CENTER:
+ case GTK_ALIGN_BASELINE:
default:
return align;
}
{
case GTK_ALIGN_BASELINE:
case GTK_ALIGN_FILL:
+ default:
/* change nothing */
break;
case GTK_ALIGN_START:
* at the last moment, since the event may have been queued
* up behind other events, held over a recursive main loop, etc.
*/
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_EXPOSE:
case GDK_MOTION_NOTIFY:
return TRUE;
/* Non input events get handled right away */
- switch (event->type)
+ switch ((guint) event->type)
{
case GDK_VISIBILITY_NOTIFY:
case GDK_EXPOSE:
switch (event->type)
{
+ case GDK_DRAG_ENTER:
+ case GDK_DRAG_LEAVE:
+ case GDK_DRAG_MOTION:
+ case GDK_DRAG_STATUS:
+ case GDK_DROP_START:
+ case GDK_DROP_FINISHED:
+ case GDK_CLIENT_EVENT:
+ case GDK_SETTING:
+ case GDK_OWNER_CHANGE:
+ case GDK_DAMAGE:
+ case GDK_EVENT_LAST:
case GDK_TOUCHPAD_SWIPE:
case GDK_TOUCHPAD_PINCH:
case GDK_PAD_BUTTON_PRESS:
case GTK_DIR_DOWN:
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
+ default:
break;
}
case GDK_BUTTON_SECONDARY:
g_object_get (settings, "gtk-titlebar-right-click", &action, NULL);
break;
+ default:
+ break;
}
if (action == NULL)
gtk_gesture_set_sequence_state (GTK_GESTURE (gesture),
sequence, GTK_EVENT_SEQUENCE_CLAIMED);
break;
+ case GTK_WINDOW_REGION_EDGE_NW:
+ case GTK_WINDOW_REGION_EDGE_N:
+ case GTK_WINDOW_REGION_EDGE_NE:
+ case GTK_WINDOW_REGION_EDGE_W:
+ case GTK_WINDOW_REGION_EDGE_E:
+ case GTK_WINDOW_REGION_EDGE_SW:
+ case GTK_WINDOW_REGION_EDGE_S:
+ case GTK_WINDOW_REGION_EDGE_SE:
default:
if (!priv->maximized)
{
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
break;
+
+ case GTK_WINDOW_REGION_EDGE_NW:
+ case GTK_WINDOW_REGION_EDGE_N:
+ case GTK_WINDOW_REGION_EDGE_NE:
+ case GTK_WINDOW_REGION_EDGE_W:
+ case GTK_WINDOW_REGION_EDGE_E:
+ case GTK_WINDOW_REGION_EDGE_SW:
+ case GTK_WINDOW_REGION_EDGE_S:
+ case GTK_WINDOW_REGION_EDGE_SE:
default:
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
}
}
break;
+ case GTK_WIN_POS_NONE:
default:
break;
}
}
break;
- default: ;
+ case GSK_NOT_A_RENDER_NODE:
+ case GSK_CONTAINER_NODE:
+ case GSK_TRANSFORM_NODE:
+ case GSK_COLOR_MATRIX_NODE:
+ case GSK_REPEAT_NODE:
+ case GSK_CLIP_NODE:
+ case GSK_ROUNDED_CLIP_NODE:
+ case GSK_SHADOW_NODE:
+ default:
+ break;
}
}
'-Wmissing-format-attribute',
'-Wmissing-include-dirs',
'-Wlogical-op',
+ '-Wswitch-default',
+ '-Wswitch-enum',
'-Werror=redundant-decls',
'-Werror=implicit',
'-Werror=nonnull',
projects / gtk4.git / commitdiff